package com.kt.learn1

/**
 * Kotlin Lambda 表达式与高阶函数示例
 * 包括 Lambda 表达式的基本用法、高阶函数的定义和使用等
 */

fun main() {
    // Lambda 表达式的基本用法
    chapter1BasicLambda()

    // 高阶函数
    chapter2HigherOrderFunctions()

    // Lambda 在集合操作中的应用
    chapter3LambdaInCollections()

    // 带接收者的 Lambda
    chapter4LambdaWithReceiver()

    // 局部函数与 Lambda
    chapter5LocalFunctionsAndLambda()
}

// Lambda 表达式的基本用法
fun chapter1BasicLambda() {
    println("\n===== Lambda 表达式的基本用法 =====")

    // 定义一个 Lambda 表达式
    val sum: (Int, Int) -> Int = { a, b -> a + b }

    // 使用 Lambda 表达式
    println("Sum of 5 and 3: ${sum(5, 3)}") // 输出：Sum of 5 and 3: 8

    // Lambda 表达式作为参数传递
    fun performOperation(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
        return operation(a, b)
    }

    val result = performOperation(5, 3, { x, y -> x * y })
    println("Multiplication of 5 and 3: $result") // 输出：Multiplication of 5 and 3: 15
}

// 高阶函数
fun chapter2HigherOrderFunctions() {
    println("\n===== 高阶函数 =====")

    // 定义一个高阶函数，接受一个函数作为参数
    fun calculate(operation: (Int, Int) -> Int, a: Int, b: Int): Int {
        return operation(a, b)
    }

    // 定义一个 Lambda 表达式作为参数传递
    println("Addition: ${calculate({ a, b -> a + b }, 10, 5)}") // 输出：Addition: 15

    // 定义一个高阶函数，返回一个函数
    fun getOperation(operator: String): (Int, Int) -> Int {
        return when (operator) {
            "+" -> { a, b -> a + b }
            "-" -> { a, b -> a - b }
            "*" -> { a, b -> a * b }
            "/" -> { a, b -> a / b }
            else -> throw IllegalArgumentException("Invalid operator")
        }
    }

    val addOperation = getOperation("+")
    println("Addition using returned function: ${addOperation(10, 5)}") // 输出：Addition using returned function: 15
}

// Lambda 在集合操作中的应用
fun chapter3LambdaInCollections() {
    println("\n===== Lambda 在集合操作中的应用 =====")

    val numbers = listOf(1, 2, 3, 4, 5)

    // 使用 Lambda 表达式进行映射操作
    val squaredNumbers = numbers.map { it * it }
    println("Squared numbers: ${squaredNumbers.joinToString()}") // 输出：Squared numbers: 1, 4, 9, 16, 25

    // 使用 Lambda 表达式进行过滤操作
    val evenNumbers = numbers.filter { it % 2 == 0 }
    println("Even numbers: ${evenNumbers.joinToString()}") // 输出：Even numbers: 2, 4

    // 使用 Lambda 表达式进行折叠操作
    val sum = numbers.fold(0) { acc, number -> acc + number }
    println("Sum of numbers: $sum") // 输出：Sum of numbers: 15
}

// 带接收者的 Lambda
fun chapter4LambdaWithReceiver() {
    println("\n===== 带接收者的 Lambda =====")

    // 定义一个数据类
    data class Person(val name: String, var age: Int)

    // 创建一个 Person 对象
    val person = Person("Alice", 30)

    // 使用 with 函数和 Lambda 表达式
    with(person) {
        println("Name: $name, Age: $age") // 输出：Name: Alice, Age: 30
    }

    // 使用 apply 函数和 Lambda 表达式
    val newPerson = Person("Bob", 25).apply {
        age = 30
    }
    println("New Person: $newPerson") // 输出：New Person: Person(name=Bob, age=30)
}

// 局部函数与 Lambda
fun chapter5LocalFunctionsAndLambda() {
    println("\n===== 局部函数与 Lambda =====")

    fun calculateSum(numbers: List<Int>): Int {
        // 局部函数
        fun sum(acc: Int, num: Int): Int {
            return acc + num
        }

        // 使用 Lambda 表达式
        return numbers.fold(0, ::sum)
    }

    val numbers = listOf(1, 2, 3, 4, 5)
    println("Sum of numbers: ${calculateSum(numbers)}") // 输出：Sum of numbers: 15
}